home *** CD-ROM | disk | FTP | other *** search
/ Sky at Night 2007 June / SAN CD 6-2007 CD-ROM 25.iso / pc / Software / AstroGrav_Win / Java / jre1.6.0 / lib / rt.jar / sun / font / FontManager.class (.txt) < prev    next >
Encoding:
Java Class File  |  2006-11-29  |  32.8 KB  |  2,067 lines
  1. package sun.font;
  2.  
  3. import java.awt.Font;
  4. import java.awt.FontFormatException;
  5. import java.awt.GraphicsEnvironment;
  6. import java.io.File;
  7. import java.security.AccessController;
  8. import java.util.ArrayList;
  9. import java.util.HashMap;
  10. import java.util.HashSet;
  11. import java.util.Hashtable;
  12. import java.util.Iterator;
  13. import java.util.Locale;
  14. import java.util.Map;
  15. import java.util.NoSuchElementException;
  16. import java.util.StringTokenizer;
  17. import java.util.TreeMap;
  18. import java.util.Vector;
  19. import java.util.concurrent.ConcurrentHashMap;
  20. import java.util.logging.Level;
  21. import java.util.logging.Logger;
  22. import javax.swing.plaf.FontUIResource;
  23. import sun.awt.AppContext;
  24. import sun.awt.FontConfiguration;
  25. import sun.awt.SunToolkit;
  26. import sun.awt.SunHints.Value;
  27. import sun.java2d.HeadlessGraphicsEnvironment;
  28. import sun.java2d.SunGraphicsEnvironment;
  29.  
  30. public final class FontManager {
  31.    public static final int FONTFORMAT_NONE = -1;
  32.    public static final int FONTFORMAT_TRUETYPE = 0;
  33.    public static final int FONTFORMAT_TYPE1 = 1;
  34.    public static final int FONTFORMAT_T2K = 2;
  35.    public static final int FONTFORMAT_TTC = 3;
  36.    public static final int FONTFORMAT_COMPOSITE = 4;
  37.    public static final int FONTFORMAT_NATIVE = 5;
  38.    public static final int NO_FALLBACK = 0;
  39.    public static final int PHYSICAL_FALLBACK = 1;
  40.    public static final int LOGICAL_FALLBACK = 2;
  41.    public static final int QUADPATHTYPE = 1;
  42.    public static final int CUBICPATHTYPE = 2;
  43.    private static final int CHANNELPOOLSIZE = 20;
  44.    private static int lastPoolIndex = 0;
  45.    private static int poolSize = 0;
  46.    private static FileFont[] fontFileCache = new FileFont[20];
  47.    private static int maxCompFont = 0;
  48.    private static CompositeFont[] compFonts = new CompositeFont[20];
  49.    private static Hashtable compositeFonts = new Hashtable();
  50.    private static Hashtable physicalFonts = new Hashtable();
  51.    private static ConcurrentHashMap<String, PhysicalFont> registeredFontFiles = new ConcurrentHashMap();
  52.    private static Hashtable fullNameToFont = new Hashtable();
  53.    private static HashMap localeFullNamesToFont;
  54.    private static PhysicalFont defaultPhysicalFont;
  55.    private static boolean usePlatformFontMetrics = false;
  56.    public static Logger logger = null;
  57.    public static boolean logging;
  58.    static boolean longAddresses;
  59.    static String osName;
  60.    static boolean useT2K;
  61.    static boolean isWindows;
  62.    static boolean isSolaris;
  63.    public static boolean isSolaris8;
  64.    public static boolean isSolaris9;
  65.    private static boolean loaded1dot0Fonts = false;
  66.    static SunGraphicsEnvironment sgEnv;
  67.    static boolean loadedAllFonts = false;
  68.    static boolean loadedAllFontFiles = false;
  69.    static TrueTypeFont eudcFont;
  70.    static HashMap<String, String> jreFontMap;
  71.    static HashSet<String> jreLucidaFontFiles;
  72.    static String[] jreOtherFontFiles;
  73.    static boolean noOtherJREFontFiles = false;
  74.    private static String[] STR_ARRAY = new String[0];
  75.    private static final Hashtable deferredFontFiles;
  76.    private static final Hashtable initialisedFonts;
  77.    private static HashMap<String, String> fontToFileMap;
  78.    private static HashMap<String, String> fontToFamilyNameMap;
  79.    private static HashMap<String, ArrayList<String>> familyToFontListMap;
  80.    private static String[] pathDirs;
  81.    private static Hashtable fontNameCache;
  82.    private static final short US_LCID = 1033;
  83.    private static Map lcidMap;
  84.    private static Thread fileCloser;
  85.    static Vector<File> tmpFontFiles;
  86.    private static final Object altJAFontKey;
  87.    private static final Object localeFontKey;
  88.    private static final Object proportionalFontKey;
  89.    public static boolean usingPerAppContextComposites;
  90.    private static boolean usingAlternateComposites;
  91.    private static boolean gAltJAFont;
  92.    private static boolean gLocalePref;
  93.    private static boolean gPropPref;
  94.    private static HashSet installedNames;
  95.    private static final Object regFamilyKey;
  96.    private static final Object regFullNameKey;
  97.    private static Hashtable<String, FontFamily> createdByFamilyName;
  98.    private static Hashtable<String, Font2D> createdByFullName;
  99.    private static boolean fontsAreRegistered;
  100.    private static boolean fontsAreRegisteredPerAppContext;
  101.    private static final String[][] nameMap;
  102.    private static String[] fontConfigNames;
  103.    private static FontConfigInfo[] fontConfigFonts;
  104.  
  105.    private static native void initIDs();
  106.  
  107.    public static void addToPool(FileFont var0) {
  108.       boolean var1 = false;
  109.       synchronized(fontFileCache) {
  110.          if (poolSize < 20) {
  111.             for(int var3 = 0; var3 < 20; ++var3) {
  112.                if (fontFileCache[var3] == null) {
  113.                   fontFileCache[var3] = var0;
  114.                   ++poolSize;
  115.                   var1 = true;
  116.                   break;
  117.                }
  118.             }
  119.  
  120.             assert var1;
  121.          } else {
  122.             assert fontFileCache[lastPoolIndex] != var0;
  123.  
  124.             fontFileCache[lastPoolIndex].close();
  125.             fontFileCache[lastPoolIndex] = var0;
  126.             lastPoolIndex = (lastPoolIndex + 1) % 20;
  127.          }
  128.  
  129.       }
  130.    }
  131.  
  132.    public static void removeFromPool(FileFont var0) {
  133.       synchronized(fontFileCache) {
  134.          for(int var2 = 0; var2 < 20; ++var2) {
  135.             if (fontFileCache[var2] == var0) {
  136.                fontFileCache[var2] = null;
  137.                --poolSize;
  138.             }
  139.          }
  140.  
  141.       }
  142.    }
  143.  
  144.    public static boolean fontSupportsDefaultEncoding(Font var0) {
  145.       return getFont2D(var0) instanceof CompositeFont;
  146.    }
  147.  
  148.    public static FontUIResource getCompositeFontUIResource(Font var0) {
  149.       FontUIResource var1 = new FontUIResource(var0.getName(), var0.getStyle(), var0.getSize());
  150.       Font2D var2 = getFont2D(var0);
  151.       if (!(var2 instanceof PhysicalFont)) {
  152.          return var1;
  153.       } else {
  154.          CompositeFont var3 = (CompositeFont)findFont2D("dialog", var0.getStyle(), 0);
  155.          if (var3 == null) {
  156.             return var1;
  157.          } else if (var3.getSlotFont(0) == var2) {
  158.             return new FontUIResource("Dialog", var0.getStyle(), var0.getSize());
  159.          } else {
  160.             PhysicalFont var4 = (PhysicalFont)var2;
  161.             CompositeFont var5 = new CompositeFont(var4, var3);
  162.             setFont2D(var1, var5.handle);
  163.             setCreatedFont(var1);
  164.             return var1;
  165.          }
  166.       }
  167.    }
  168.  
  169.    public static Font2DHandle getNewComposite(String var0, int var1, Font2DHandle var2) {
  170.       if (!(var2.font2D instanceof CompositeFont)) {
  171.          return var2;
  172.       } else {
  173.          CompositeFont var3 = (CompositeFont)var2.font2D;
  174.          PhysicalFont var4 = var3.getSlotFont(0);
  175.          if (var0 == null) {
  176.             var0 = var4.getFamilyName((Locale)null);
  177.          }
  178.  
  179.          if (var1 == -1) {
  180.             var1 = var3.getStyle();
  181.          }
  182.  
  183.          Object var5 = findFont2D(var0, var1, 0);
  184.          if (!(var5 instanceof PhysicalFont)) {
  185.             var5 = var4;
  186.          }
  187.  
  188.          PhysicalFont var6 = (PhysicalFont)var5;
  189.          CompositeFont var7 = (CompositeFont)findFont2D("dialog", var1, 0);
  190.          if (var7 == null) {
  191.             return var2;
  192.          } else {
  193.             CompositeFont var8 = new CompositeFont(var6, var7);
  194.             Font2DHandle var9 = new Font2DHandle(var8);
  195.             return var9;
  196.          }
  197.       }
  198.    }
  199.  
  200.    public static native void setFont2D(Font var0, Font2DHandle var1);
  201.  
  202.    private static native boolean isCreatedFont(Font var0);
  203.  
  204.    private static native void setCreatedFont(Font var0);
  205.  
  206.    public static void registerCompositeFont(String var0, String[] var1, String[] var2, int var3, int[] var4, int[] var5, boolean var6) {
  207.       CompositeFont var7 = new CompositeFont(var0, var1, var2, var3, var4, var5, var6);
  208.       addCompositeToFontList(var7, 2);
  209.       synchronized(compFonts) {
  210.          compFonts[maxCompFont++] = var7;
  211.       }
  212.    }
  213.  
  214.    public static void registerCompositeFont(String var0, String[] var1, String[] var2, int var3, int[] var4, int[] var5, boolean var6, Hashtable var7) {
  215.       CompositeFont var8 = new CompositeFont(var0, var1, var2, var3, var4, var5, var6);
  216.       Font2D var9 = (Font2D)var7.get(var0.toLowerCase(Locale.ENGLISH));
  217.       if (var9 instanceof CompositeFont) {
  218.          var9.handle.font2D = var8;
  219.       }
  220.  
  221.       var7.put(var0.toLowerCase(Locale.ENGLISH), var8);
  222.    }
  223.  
  224.    private static void addCompositeToFontList(CompositeFont var0, int var1) {
  225.       if (logging) {
  226.          logger.info("Add to Family " + var0.familyName + ", Font " + var0.fullName + " rank=" + var1);
  227.       }
  228.  
  229.       var0.setRank(var1);
  230.       compositeFonts.put(var0.fullName, var0);
  231.       fullNameToFont.put(var0.fullName.toLowerCase(Locale.ENGLISH), var0);
  232.       FontFamily var2 = FontFamily.getFamily(var0.familyName);
  233.       if (var2 == null) {
  234.          var2 = new FontFamily(var0.familyName, true, var1);
  235.       }
  236.  
  237.       var2.setFont(var0, var0.style);
  238.    }
  239.  
  240.    private static PhysicalFont addToFontList(PhysicalFont var0, int var1) {
  241.       String var2 = var0.fullName;
  242.       String var3 = var0.familyName;
  243.       if (var2 != null && !"".equals(var2)) {
  244.          if (compositeFonts.containsKey(var2)) {
  245.             return null;
  246.          } else {
  247.             var0.setRank(var1);
  248.             if (!physicalFonts.containsKey(var2)) {
  249.                if (logging) {
  250.                   logger.info("Add to Family " + var3 + ", Font " + var2 + " rank=" + var1);
  251.                }
  252.  
  253.                physicalFonts.put(var2, var0);
  254.                FontFamily var4 = FontFamily.getFamily(var3);
  255.                if (var4 == null) {
  256.                   var4 = new FontFamily(var3, false, var1);
  257.                   var4.setFont(var0, var0.style);
  258.                } else if (var4.getRank() >= var1) {
  259.                   var4.setFont(var0, var0.style);
  260.                }
  261.  
  262.                fullNameToFont.put(var2.toLowerCase(Locale.ENGLISH), var0);
  263.                return var0;
  264.             } else {
  265.                PhysicalFont var5 = (PhysicalFont)physicalFonts.get(var2);
  266.                if (var5 == null) {
  267.                   return null;
  268.                } else if (var5.getRank() >= var1) {
  269.                   if (var5.mapper != null && var1 > 2) {
  270.                      return var5;
  271.                   } else {
  272.                      if (var5.getRank() == var1) {
  273.                         if (!(var5 instanceof TrueTypeFont) || !(var0 instanceof TrueTypeFont)) {
  274.                            return var5;
  275.                         }
  276.  
  277.                         TrueTypeFont var6 = (TrueTypeFont)var5;
  278.                         TrueTypeFont var7 = (TrueTypeFont)var0;
  279.                         if (var6.fileSize >= var7.fileSize) {
  280.                            return var5;
  281.                         }
  282.                      }
  283.  
  284.                      if (var5.platName.startsWith(SunGraphicsEnvironment.jreFontDirName)) {
  285.                         if (logging) {
  286.                            logger.warning("Unexpected attempt to replace a JRE  font " + var2 + " from " + var5.platName + " with " + var0.platName);
  287.                         }
  288.  
  289.                         return var5;
  290.                      } else {
  291.                         if (logging) {
  292.                            logger.info("Replace in Family " + var3 + ",Font " + var2 + " new rank=" + var1 + " from " + var5.platName + " with " + var0.platName);
  293.                         }
  294.  
  295.                         replaceFont(var5, var0);
  296.                         physicalFonts.put(var2, var0);
  297.                         fullNameToFont.put(var2.toLowerCase(Locale.ENGLISH), var0);
  298.                         FontFamily var9 = FontFamily.getFamily(var3);
  299.                         if (var9 == null) {
  300.                            var9 = new FontFamily(var3, false, var1);
  301.                            var9.setFont(var0, var0.style);
  302.                         } else if (var9.getRank() >= var1) {
  303.                            var9.setFont(var0, var0.style);
  304.                         }
  305.  
  306.                         return var0;
  307.                      }
  308.                   }
  309.                } else {
  310.                   return var5;
  311.                }
  312.             }
  313.          }
  314.       } else {
  315.          return null;
  316.       }
  317.    }
  318.  
  319.    public static Font2D[] getRegisteredFonts() {
  320.       PhysicalFont[] var0 = getPhysicalFonts();
  321.       int var1 = maxCompFont;
  322.       Font2D[] var2 = new Font2D[var0.length + var1];
  323.       System.arraycopy(compFonts, 0, var2, 0, var1);
  324.       System.arraycopy(var0, 0, var2, var1, var0.length);
  325.       return var2;
  326.    }
  327.  
  328.    public static PhysicalFont[] getPhysicalFonts() {
  329.       return (PhysicalFont[])physicalFonts.values().toArray(new PhysicalFont[0]);
  330.    }
  331.  
  332.    public static synchronized void initialiseDeferredFonts() {
  333.       String[] var0 = (String[])deferredFontFiles.keySet().toArray(STR_ARRAY);
  334.  
  335.       for(int var1 = 0; var1 < var0.length; ++var1) {
  336.          initialiseDeferredFont(var0[var1]);
  337.       }
  338.  
  339.    }
  340.  
  341.    public static synchronized void registerDeferredJREFonts(String var0) {
  342.       FontRegistrationInfo[] var1 = (FontRegistrationInfo[])deferredFontFiles.values().toArray(new FontRegistrationInfo[0]);
  343.  
  344.       for(int var2 = 0; var2 < var1.length; ++var2) {
  345.          if (var1[var2].fontFilePath != null && var1[var2].fontFilePath.startsWith(var0)) {
  346.             initialiseDeferredFont(var1[var2].fontFilePath);
  347.          }
  348.       }
  349.  
  350.    }
  351.  
  352.    private static PhysicalFont findJREDeferredFont(String var0, int var1) {
  353.       String var3 = var0.toLowerCase(Locale.ENGLISH) + var1;
  354.       String var4 = (String)jreFontMap.get(var3);
  355.       if (var4 != null) {
  356.          initSGEnv();
  357.          var4 = SunGraphicsEnvironment.jreFontDirName + File.separator + var4;
  358.          if (deferredFontFiles.get(var4) != null) {
  359.             PhysicalFont var2 = initialiseDeferredFont(var4);
  360.             if (var2 != null && (var2.getFontName((Locale)null).equalsIgnoreCase(var0) || var2.getFamilyName((Locale)null).equalsIgnoreCase(var0)) && var2.style == var1) {
  361.                return var2;
  362.             }
  363.          }
  364.       }
  365.  
  366.       if (noOtherJREFontFiles) {
  367.          return null;
  368.       } else {
  369.          synchronized(jreLucidaFontFiles) {
  370.             if (jreOtherFontFiles == null) {
  371.                HashSet var6 = new HashSet();
  372.                String[] var7 = (String[])deferredFontFiles.keySet().toArray(STR_ARRAY);
  373.  
  374.                for(int var8 = 0; var8 < var7.length; ++var8) {
  375.                   File var9 = new File(var7[var8]);
  376.                   String var10 = var9.getParent();
  377.                   String var11 = var9.getName();
  378.                   if (var10 != null && var10.equals(SunGraphicsEnvironment.jreFontDirName) && !jreLucidaFontFiles.contains(var11)) {
  379.                      var6.add(var7[var8]);
  380.                   }
  381.                }
  382.  
  383.                jreOtherFontFiles = (String[])var6.toArray(STR_ARRAY);
  384.                if (jreOtherFontFiles.length == 0) {
  385.                   noOtherJREFontFiles = true;
  386.                }
  387.             }
  388.  
  389.             for(int var17 = 0; var17 < jreOtherFontFiles.length; ++var17) {
  390.                var4 = jreOtherFontFiles[var17];
  391.                if (var4 != null) {
  392.                   jreOtherFontFiles[var17] = null;
  393.                   PhysicalFont var14 = initialiseDeferredFont(var4);
  394.                   if (var14 != null && (var14.getFontName((Locale)null).equalsIgnoreCase(var0) || var14.getFamilyName((Locale)null).equalsIgnoreCase(var0)) && var14.style == var1) {
  395.                      return var14;
  396.                   }
  397.                }
  398.             }
  399.  
  400.             return null;
  401.          }
  402.       }
  403.    }
  404.  
  405.    private static PhysicalFont findOtherDeferredFont(String var0, int var1) {
  406.       String[] var2 = (String[])deferredFontFiles.keySet().toArray(STR_ARRAY);
  407.  
  408.       for(int var3 = 0; var3 < var2.length; ++var3) {
  409.          File var4 = new File(var2[var3]);
  410.          String var5 = var4.getParent();
  411.          String var6 = var4.getName();
  412.          if (var5 == null || !var5.equals(SunGraphicsEnvironment.jreFontDirName) || !jreLucidaFontFiles.contains(var6)) {
  413.             PhysicalFont var7 = initialiseDeferredFont(var2[var3]);
  414.             if (var7 != null && (var7.getFontName((Locale)null).equalsIgnoreCase(var0) || var7.getFamilyName((Locale)null).equalsIgnoreCase(var0)) && var7.style == var1) {
  415.                return var7;
  416.             }
  417.          }
  418.       }
  419.  
  420.       return null;
  421.    }
  422.  
  423.    private static PhysicalFont findDeferredFont(String var0, int var1) {
  424.       PhysicalFont var2 = findJREDeferredFont(var0, var1);
  425.       return var2 != null ? var2 : findOtherDeferredFont(var0, var1);
  426.    }
  427.  
  428.    public static void registerDeferredFont(String var0, String var1, String[] var2, int var3, boolean var4, int var5) {
  429.       FontRegistrationInfo var6 = new FontRegistrationInfo(var1, var2, var3, var4, var5);
  430.       deferredFontFiles.put(var0, var6);
  431.    }
  432.  
  433.    public static synchronized PhysicalFont initialiseDeferredFont(String var0) {
  434.       if (var0 == null) {
  435.          return null;
  436.       } else {
  437.          if (logging) {
  438.             logger.info("Opening deferred font file " + var0);
  439.          }
  440.  
  441.          FontRegistrationInfo var2 = (FontRegistrationInfo)deferredFontFiles.get(var0);
  442.          PhysicalFont var1;
  443.          if (var2 != null) {
  444.             deferredFontFiles.remove(var0);
  445.             var1 = registerFontFile(var2.fontFilePath, var2.nativeNames, var2.fontFormat, var2.javaRasterizer, var2.fontRank);
  446.             if (var1 != null) {
  447.                initialisedFonts.put(var0, var1.handle);
  448.             } else {
  449.                initialisedFonts.put(var0, getDefaultPhysicalFont().handle);
  450.             }
  451.          } else {
  452.             Font2DHandle var3 = (Font2DHandle)initialisedFonts.get(var0);
  453.             if (var3 == null) {
  454.                var1 = getDefaultPhysicalFont();
  455.             } else {
  456.                var1 = (PhysicalFont)var3.font2D;
  457.             }
  458.          }
  459.  
  460.          return var1;
  461.       }
  462.    }
  463.  
  464.    public static PhysicalFont registerFontFile(String var0, String[] var1, int var2, boolean var3, int var4) {
  465.       PhysicalFont var5 = (PhysicalFont)registeredFontFiles.get(var0);
  466.       if (var5 != null) {
  467.          return var5;
  468.       } else {
  469.          PhysicalFont var6 = null;
  470.  
  471.          try {
  472.             label39:
  473.             switch (var2) {
  474.                case 0:
  475.                   int var8 = 0;
  476.  
  477.                   while(true) {
  478.                      TrueTypeFont var9 = new TrueTypeFont(var0, var1, var8++, var3);
  479.                      PhysicalFont var13 = addToFontList(var9, var4);
  480.                      if (var6 == null) {
  481.                         var6 = var13;
  482.                      }
  483.  
  484.                      if (var8 >= var9.getFontCount()) {
  485.                         break label39;
  486.                      }
  487.                   }
  488.                case 1:
  489.                   Type1Font var10 = new Type1Font(var0, var1);
  490.                   var6 = addToFontList(var10, var4);
  491.                   break;
  492.                case 5:
  493.                   NativeFont var11 = new NativeFont(var0, false);
  494.                   var6 = addToFontList(var11, var4);
  495.             }
  496.  
  497.             if (logging) {
  498.                logger.info("Registered file " + var0 + " as font " + var6 + " rank=" + var4);
  499.             }
  500.          } catch (FontFormatException var12) {
  501.             if (logging) {
  502.                logger.warning("Unusable font: " + var0 + " " + var12.toString());
  503.             }
  504.          }
  505.  
  506.          if (var6 != null && var2 != 5) {
  507.             registeredFontFiles.put(var0, var6);
  508.          }
  509.  
  510.          return var6;
  511.       }
  512.    }
  513.  
  514.    public static void registerFonts(String[] var0, String[][] var1, int var2, int var3, boolean var4, int var5, boolean var6) {
  515.       for(int var7 = 0; var7 < var2; ++var7) {
  516.          if (var6) {
  517.             registerDeferredFont(var0[var7], var0[var7], var1[var7], var3, var4, var5);
  518.          } else {
  519.             registerFontFile(var0[var7], var1[var7], var3, var4, var5);
  520.          }
  521.       }
  522.  
  523.    }
  524.  
  525.    public static PhysicalFont getDefaultPhysicalFont() {
  526.       if (defaultPhysicalFont == null) {
  527.          defaultPhysicalFont = (PhysicalFont)findFont2D("Lucida Sans Regular", 0, 0);
  528.          if (defaultPhysicalFont == null) {
  529.             defaultPhysicalFont = (PhysicalFont)findFont2D("Arial", 0, 0);
  530.          }
  531.  
  532.          if (defaultPhysicalFont == null) {
  533.             Iterator var0 = physicalFonts.values().iterator();
  534.             if (!var0.hasNext()) {
  535.                throw new Error("Probable fatal error:No fonts found.");
  536.             }
  537.  
  538.             defaultPhysicalFont = (PhysicalFont)var0.next();
  539.          }
  540.       }
  541.  
  542.       return defaultPhysicalFont;
  543.    }
  544.  
  545.    public static CompositeFont getDefaultLogicalFont(int var0) {
  546.       return (CompositeFont)findFont2D("dialog", var0, 0);
  547.    }
  548.  
  549.    private static String dotStyleStr(int var0) {
  550.       switch (var0) {
  551.          case 1:
  552.             return ".bold";
  553.          case 2:
  554.             return ".italic";
  555.          case 3:
  556.             return ".bolditalic";
  557.          default:
  558.             return ".plain";
  559.       }
  560.    }
  561.  
  562.    static void initSGEnv() {
  563.       if (sgEnv == null) {
  564.          GraphicsEnvironment var0 = GraphicsEnvironment.getLocalGraphicsEnvironment();
  565.          if (var0 instanceof HeadlessGraphicsEnvironment) {
  566.             HeadlessGraphicsEnvironment var1 = (HeadlessGraphicsEnvironment)var0;
  567.             sgEnv = (SunGraphicsEnvironment)var1.getSunGraphicsEnvironment();
  568.          } else {
  569.             sgEnv = (SunGraphicsEnvironment)var0;
  570.          }
  571.       }
  572.  
  573.    }
  574.  
  575.    private static native void populateFontFileNameMap(HashMap<String, String> var0, HashMap<String, String> var1, HashMap<String, ArrayList<String>> var2, Locale var3);
  576.  
  577.    private static String[] getFontFilesFromPath() {
  578.       return (String[])AccessController.doPrivileged(new 2());
  579.    }
  580.  
  581.    private static void resolveWindowsFonts() {
  582.       ArrayList var0 = null;
  583.  
  584.       for(String var2 : fontToFamilyNameMap.keySet()) {
  585.          String var3 = (String)fontToFileMap.get(var2);
  586.          if (var3 == null) {
  587.             if (var2.indexOf("  ") > 0) {
  588.                String var4 = var2.replaceFirst("  ", " ");
  589.                var3 = (String)fontToFileMap.get(var4);
  590.                if (var3 != null && !fontToFamilyNameMap.containsKey(var4)) {
  591.                   fontToFileMap.remove(var4);
  592.                   fontToFileMap.put(var2, var3);
  593.                }
  594.             } else if (var2.equals("marlett")) {
  595.                fontToFileMap.put(var2, "marlett.ttf");
  596.             } else if (var2.equals("david")) {
  597.                var3 = (String)fontToFileMap.get("david regular");
  598.                if (var3 != null) {
  599.                   fontToFileMap.remove("david regular");
  600.                   fontToFileMap.put("david", var3);
  601.                }
  602.             } else {
  603.                if (var0 == null) {
  604.                   var0 = new ArrayList();
  605.                }
  606.  
  607.                var0.add(var2);
  608.             }
  609.          }
  610.       }
  611.  
  612.       if (var0 != null) {
  613.          HashSet var8 = new HashSet();
  614.          HashMap var9 = (HashMap)fontToFileMap.clone();
  615.  
  616.          for(String var16 : fontToFamilyNameMap.keySet()) {
  617.             var9.remove(var16);
  618.          }
  619.  
  620.          for(String var17 : var9.keySet()) {
  621.             var8.add(var9.get(var17));
  622.             fontToFileMap.remove(var17);
  623.          }
  624.  
  625.          resolveFontFiles(var8, var0);
  626.          if (var0.size() > 0) {
  627.             ArrayList var14 = new ArrayList();
  628.  
  629.             for(String var5 : fontToFileMap.values()) {
  630.                var14.add(var5.toLowerCase());
  631.             }
  632.  
  633.             for(String var7 : getFontFilesFromPath()) {
  634.                if (!var14.contains(var7)) {
  635.                   var8.add(var7);
  636.                }
  637.             }
  638.  
  639.             resolveFontFiles(var8, var0);
  640.          }
  641.  
  642.          if (var0.size() > 0) {
  643.             int var15 = var0.size();
  644.  
  645.             for(int var20 = 0; var20 < var15; ++var20) {
  646.                String var22 = (String)var0.get(var20);
  647.                String var23 = (String)fontToFamilyNameMap.get(var22);
  648.                if (var23 != null) {
  649.                   ArrayList var24 = (ArrayList)familyToFontListMap.get(var23);
  650.                   if (var24 != null && var24.size() <= 1) {
  651.                      familyToFontListMap.remove(var23);
  652.                   }
  653.                }
  654.  
  655.                fontToFamilyNameMap.remove(var22);
  656.                if (logging) {
  657.                   logger.info("No file for font:" + var22);
  658.                }
  659.             }
  660.          }
  661.       }
  662.  
  663.    }
  664.  
  665.    private static void resolveFontFiles(HashSet<String> var0, ArrayList<String> var1) {
  666.       Locale var2 = SunToolkit.getStartupLocale();
  667.  
  668.       for(String var4 : var0) {
  669.          try {
  670.             int var5 = 0;
  671.             String var7 = getPathName(var4);
  672.             if (logging) {
  673.                logger.info("Trying to resolve file " + var7);
  674.             }
  675.  
  676.             while(true) {
  677.                TrueTypeFont var6 = new TrueTypeFont(var7, (Object)null, var5++, true);
  678.                String var8 = var6.getFontName(var2).toLowerCase();
  679.                if (var1.contains(var8)) {
  680.                   fontToFileMap.put(var8, var4);
  681.                   var1.remove(var8);
  682.                   if (logging) {
  683.                      logger.info("Resolved absent registry entry for " + var8 + " located in " + var7);
  684.                   }
  685.                }
  686.  
  687.                if (var5 >= var6.getFontCount()) {
  688.                   break;
  689.                }
  690.             }
  691.          } catch (Exception var9) {
  692.          }
  693.       }
  694.  
  695.    }
  696.  
  697.    private static synchronized HashMap<String, String> getFullNameToFileMap() {
  698.       if (fontToFileMap == null) {
  699.          StringTokenizer var0 = new StringTokenizer(getFontPath(SunGraphicsEnvironment.noType1Font), File.pathSeparator);
  700.          ArrayList var1 = new ArrayList();
  701.  
  702.          try {
  703.             while(var0.hasMoreTokens()) {
  704.                var1.add(var0.nextToken());
  705.             }
  706.          } catch (NoSuchElementException var3) {
  707.          }
  708.  
  709.          pathDirs = (String[])var1.toArray(STR_ARRAY);
  710.          fontToFileMap = new HashMap(100);
  711.          fontToFamilyNameMap = new HashMap(100);
  712.          familyToFontListMap = new HashMap(50);
  713.          populateFontFileNameMap(fontToFileMap, fontToFamilyNameMap, familyToFontListMap, Locale.ENGLISH);
  714.          if (isWindows) {
  715.             resolveWindowsFonts();
  716.          }
  717.  
  718.          if (logging) {
  719.             logPlatformFontInfo();
  720.          }
  721.       }
  722.  
  723.       return fontToFileMap;
  724.    }
  725.  
  726.    private static void logPlatformFontInfo() {
  727.       for(int var0 = 0; var0 < pathDirs.length; ++var0) {
  728.          logger.info("fontdir=" + pathDirs[var0]);
  729.       }
  730.  
  731.       for(String var1 : fontToFileMap.keySet()) {
  732.          logger.info("font=" + var1 + " file=" + (String)fontToFileMap.get(var1));
  733.       }
  734.  
  735.       for(String var5 : fontToFamilyNameMap.keySet()) {
  736.          logger.info("font=" + var5 + " family=" + (String)fontToFamilyNameMap.get(var5));
  737.       }
  738.  
  739.       for(String var6 : familyToFontListMap.keySet()) {
  740.          logger.info("family=" + var6 + " fonts=" + familyToFontListMap.get(var6));
  741.       }
  742.  
  743.    }
  744.  
  745.    public static String[] getFontNamesFromPlatform() {
  746.       if (getFullNameToFileMap().size() == 0) {
  747.          return null;
  748.       } else {
  749.          ArrayList var0 = new ArrayList();
  750.  
  751.          for(ArrayList var2 : familyToFontListMap.values()) {
  752.             for(String var4 : var2) {
  753.                var0.add(var4);
  754.             }
  755.          }
  756.  
  757.          return (String[])var0.toArray(STR_ARRAY);
  758.       }
  759.    }
  760.  
  761.    public static boolean gotFontsFromPlatform() {
  762.       return getFullNameToFileMap().size() != 0;
  763.    }
  764.  
  765.    public static String getFileNameForFontName(String var0) {
  766.       String var1 = var0.toLowerCase(Locale.ENGLISH);
  767.       return (String)fontToFileMap.get(var1);
  768.    }
  769.  
  770.    public static void registerOtherFontFiles(HashSet var0) {
  771.       if (getFullNameToFileMap().size() != 0) {
  772.          String[] var1 = (String[])fontToFileMap.values().toArray(STR_ARRAY);
  773.  
  774.          for(int var2 = 0; var2 < var1.length; ++var2) {
  775.             if ((new File(var1[var2])).isAbsolute() && !var0.contains(var1[var2])) {
  776.                byte var3 = -1;
  777.                byte var4 = 6;
  778.                if (SunGraphicsEnvironment.ttFilter.accept((File)null, var1[var2])) {
  779.                   var3 = 0;
  780.                   var4 = 3;
  781.                } else if (SunGraphicsEnvironment.t1Filter.accept((File)null, var1[var2])) {
  782.                   var3 = 1;
  783.                   var4 = 4;
  784.                }
  785.  
  786.                if (var3 != -1) {
  787.                   registerFontFile(var1[var2], (String[])null, var3, false, var4);
  788.                }
  789.             }
  790.          }
  791.  
  792.       }
  793.    }
  794.  
  795.    public static boolean getFamilyNamesFromPlatform(TreeMap<String, String> var0, Locale var1) {
  796.       if (getFullNameToFileMap().size() == 0) {
  797.          return false;
  798.       } else {
  799.          String[] var2 = (String[])fontToFamilyNameMap.values().toArray(STR_ARRAY);
  800.  
  801.          for(int var3 = 0; var3 < var2.length; ++var3) {
  802.             var0.put(var2[var3].toLowerCase(var1), var2[var3]);
  803.          }
  804.  
  805.          return true;
  806.       }
  807.    }
  808.  
  809.    private static String getPathName(String var0) {
  810.       File var1 = new File(var0);
  811.       if (var1.isAbsolute()) {
  812.          return var0;
  813.       } else if (pathDirs.length == 1) {
  814.          return pathDirs[0] + File.separator + var0;
  815.       } else {
  816.          for(int var2 = 0; var2 < pathDirs.length; ++var2) {
  817.             var1 = new File(pathDirs[var2] + File.separator + var0);
  818.             if (var1.exists()) {
  819.                return var1.getAbsolutePath();
  820.             }
  821.          }
  822.  
  823.          return var0;
  824.       }
  825.    }
  826.  
  827.    private static Font2D findFontFromPlatform(String var0, int var1) {
  828.       if (getFullNameToFileMap().size() == 0) {
  829.          return null;
  830.       } else {
  831.          Object var2 = null;
  832.          String var3 = null;
  833.          String var4 = (String)fontToFamilyNameMap.get(var0);
  834.          ArrayList var10;
  835.          if (var4 != null) {
  836.             var3 = (String)fontToFileMap.get(var0);
  837.             var10 = (ArrayList)familyToFontListMap.get(var4.toLowerCase(Locale.ENGLISH));
  838.          } else {
  839.             var10 = (ArrayList)familyToFontListMap.get(var0);
  840.             if (var10 != null && var10.size() > 0) {
  841.                String var5 = ((String)var10.get(0)).toLowerCase(Locale.ENGLISH);
  842.                if (var5 != null) {
  843.                   var4 = (String)fontToFamilyNameMap.get(var5);
  844.                }
  845.             }
  846.          }
  847.  
  848.          if (var10 != null && var4 != null) {
  849.             String[] var11 = (String[])var10.toArray(STR_ARRAY);
  850.             if (var11.length == 0) {
  851.                return null;
  852.             } else {
  853.                for(int var6 = 0; var6 < var11.length; ++var6) {
  854.                   String var7 = var11[var6].toLowerCase(Locale.ENGLISH);
  855.                   String var8 = (String)fontToFileMap.get(var7);
  856.                   if (var8 == null) {
  857.                      if (logging) {
  858.                         logger.info("Platform lookup : No file for font " + var11[var6] + " in family " + var4);
  859.                      }
  860.  
  861.                      return null;
  862.                   }
  863.                }
  864.  
  865.                PhysicalFont var12 = null;
  866.                if (var3 != null) {
  867.                   var12 = registerFontFile(getPathName(var3), (String[])null, 0, false, 3);
  868.                }
  869.  
  870.                for(int var13 = 0; var13 < var11.length; ++var13) {
  871.                   String var15 = var11[var13].toLowerCase(Locale.ENGLISH);
  872.                   String var9 = (String)fontToFileMap.get(var15);
  873.                   if (var3 == null || !var3.equals(var9)) {
  874.                      registerFontFile(getPathName(var9), (String[])null, 0, false, 3);
  875.                   }
  876.                }
  877.  
  878.                Font2D var14 = null;
  879.                FontFamily var16 = FontFamily.getFamily(var4);
  880.                if (var12 != null) {
  881.                   var1 |= var12.style;
  882.                }
  883.  
  884.                if (var16 != null) {
  885.                   var14 = var16.getFont(var1);
  886.                   if (var14 == null) {
  887.                      var14 = var16.getClosestStyle(var1);
  888.                   }
  889.                }
  890.  
  891.                return var14;
  892.             }
  893.          } else {
  894.             return null;
  895.          }
  896.       }
  897.    }
  898.  
  899.    public static Font2D findFont2D(String var0, int var1, int var2) {
  900.       String var3 = var0.toLowerCase(Locale.ENGLISH);
  901.       String var4 = var3 + dotStyleStr(var1);
  902.       Font2D var5;
  903.       if (usingPerAppContextComposites) {
  904.          Hashtable var6 = (Hashtable)AppContext.getAppContext().get(CompositeFont.class);
  905.          if (var6 != null) {
  906.             var5 = (Font2D)var6.get(var4);
  907.          } else {
  908.             var5 = null;
  909.          }
  910.       } else {
  911.          var5 = (Font2D)fontNameCache.get(var4);
  912.       }
  913.  
  914.       if (var5 != null) {
  915.          return var5;
  916.       } else {
  917.          if (logging) {
  918.             logger.info("Search for font: " + var0);
  919.          }
  920.  
  921.          if (isWindows) {
  922.             if (var3.equals("ms sans serif")) {
  923.                var0 = "sansserif";
  924.             } else if (var3.equals("ms serif")) {
  925.                var0 = "serif";
  926.             }
  927.          }
  928.  
  929.          if (var3.equals("default")) {
  930.             var0 = "dialog";
  931.          }
  932.  
  933.          FontFamily var23 = FontFamily.getFamily(var0);
  934.          if (var23 != null) {
  935.             var5 = var23.getFontWithExactStyleMatch(var1);
  936.             if (var5 == null) {
  937.                var5 = findDeferredFont(var0, var1);
  938.             }
  939.  
  940.             if (var5 == null) {
  941.                var5 = var23.getFont(var1);
  942.             }
  943.  
  944.             if (var5 == null) {
  945.                var5 = var23.getClosestStyle(var1);
  946.             }
  947.  
  948.             if (var5 != null) {
  949.                fontNameCache.put(var4, var5);
  950.                return var5;
  951.             }
  952.          }
  953.  
  954.          var5 = (Font2D)fullNameToFont.get(var3);
  955.          if (var5 != null) {
  956.             if (var5.style == var1 || var1 == 0) {
  957.                fontNameCache.put(var4, var5);
  958.                return var5;
  959.             }
  960.  
  961.             var23 = FontFamily.getFamily(var5.getFamilyName((Locale)null));
  962.             if (var23 != null) {
  963.                Font2D var7 = var23.getFont(var1 | var5.style);
  964.                if (var7 != null) {
  965.                   fontNameCache.put(var4, var7);
  966.                   return var7;
  967.                }
  968.  
  969.                var7 = var23.getClosestStyle(var1 | var5.style);
  970.                if (var7 != null && var7.canDoStyle(var1 | var5.style)) {
  971.                   fontNameCache.put(var4, var7);
  972.                   return var7;
  973.                }
  974.             }
  975.          }
  976.  
  977.          if (sgEnv == null) {
  978.             initSGEnv();
  979.             return findFont2D(var0, var1, var2);
  980.          } else {
  981.             if (isWindows) {
  982.                if (deferredFontFiles.size() > 0) {
  983.                   var5 = findJREDeferredFont(var3, var1);
  984.                   if (var5 != null) {
  985.                      fontNameCache.put(var4, var5);
  986.                      return var5;
  987.                   }
  988.                }
  989.  
  990.                var5 = findFontFromPlatform(var3, var1);
  991.                if (var5 != null) {
  992.                   if (logging) {
  993.                      logger.info("Found font via platform API for request:\"" + var0 + "\":, style=" + var1 + " found font: " + var5);
  994.                   }
  995.  
  996.                   fontNameCache.put(var4, var5);
  997.                   return var5;
  998.                }
  999.             }
  1000.  
  1001.             if (deferredFontFiles.size() > 0) {
  1002.                var5 = findDeferredFont(var0, var1);
  1003.                if (var5 != null) {
  1004.                   fontNameCache.put(var4, var5);
  1005.                   return var5;
  1006.                }
  1007.             }
  1008.  
  1009.             if (isSolaris && !loaded1dot0Fonts) {
  1010.                if (var3.equals("timesroman")) {
  1011.                   var5 = findFont2D("serif", var1, var2);
  1012.                   fontNameCache.put(var4, var5);
  1013.                }
  1014.  
  1015.                sgEnv.register1dot0Fonts();
  1016.                loaded1dot0Fonts = true;
  1017.                Font2D var30 = findFont2D(var0, var1, var2);
  1018.                return var30;
  1019.             } else {
  1020.                if (fontsAreRegistered || fontsAreRegisteredPerAppContext) {
  1021.                   Object var27 = null;
  1022.                   Hashtable var8;
  1023.                   Hashtable var28;
  1024.                   if (fontsAreRegistered) {
  1025.                      var28 = createdByFamilyName;
  1026.                      var8 = createdByFullName;
  1027.                   } else {
  1028.                      AppContext var9 = AppContext.getAppContext();
  1029.                      var28 = (Hashtable)var9.get(regFamilyKey);
  1030.                      var8 = (Hashtable)var9.get(regFullNameKey);
  1031.                   }
  1032.  
  1033.                   var23 = (FontFamily)var28.get(var3);
  1034.                   if (var23 != null) {
  1035.                      var5 = var23.getFontWithExactStyleMatch(var1);
  1036.                      if (var5 == null) {
  1037.                         var5 = var23.getFont(var1);
  1038.                      }
  1039.  
  1040.                      if (var5 == null) {
  1041.                         var5 = var23.getClosestStyle(var1);
  1042.                      }
  1043.  
  1044.                      if (var5 != null) {
  1045.                         if (fontsAreRegistered) {
  1046.                            fontNameCache.put(var4, var5);
  1047.                         }
  1048.  
  1049.                         return var5;
  1050.                      }
  1051.                   }
  1052.  
  1053.                   var5 = (Font2D)var8.get(var3);
  1054.                   if (var5 != null) {
  1055.                      if (fontsAreRegistered) {
  1056.                         fontNameCache.put(var4, var5);
  1057.                      }
  1058.  
  1059.                      return var5;
  1060.                   }
  1061.                }
  1062.  
  1063.                if (!loadedAllFonts) {
  1064.                   if (logging) {
  1065.                      logger.info("Load fonts looking for:" + var0);
  1066.                   }
  1067.  
  1068.                   sgEnv.loadFonts();
  1069.                   loadedAllFonts = true;
  1070.                   return findFont2D(var0, var1, var2);
  1071.                } else if (!loadedAllFontFiles) {
  1072.                   if (logging) {
  1073.                      logger.info("Load font files looking for:" + var0);
  1074.                   }
  1075.  
  1076.                   sgEnv.loadFontFiles();
  1077.                   loadedAllFontFiles = true;
  1078.                   return findFont2D(var0, var1, var2);
  1079.                } else if ((var5 = findFont2DAllLocales(var0, var1)) != null) {
  1080.                   fontNameCache.put(var4, var5);
  1081.                   return var5;
  1082.                } else {
  1083.                   if (isWindows) {
  1084.                      String var29 = sgEnv.getFontConfiguration().getFallbackFamilyName(var0, (String)null);
  1085.                      if (var29 != null) {
  1086.                         var5 = findFont2D(var29, var1, var2);
  1087.                         fontNameCache.put(var4, var5);
  1088.                         return var5;
  1089.                      }
  1090.                   } else {
  1091.                      if (var3.equals("timesroman")) {
  1092.                         var5 = findFont2D("serif", var1, var2);
  1093.                         fontNameCache.put(var4, var5);
  1094.                         return var5;
  1095.                      }
  1096.  
  1097.                      if (var3.equals("helvetica")) {
  1098.                         var5 = findFont2D("sansserif", var1, var2);
  1099.                         fontNameCache.put(var4, var5);
  1100.                         return var5;
  1101.                      }
  1102.  
  1103.                      if (var3.equals("courier")) {
  1104.                         var5 = findFont2D("monospaced", var1, var2);
  1105.                         fontNameCache.put(var4, var5);
  1106.                         return var5;
  1107.                      }
  1108.                   }
  1109.  
  1110.                   if (logging) {
  1111.                      logger.info("No font found for:" + var0);
  1112.                   }
  1113.  
  1114.                   switch (var2) {
  1115.                      case 1:
  1116.                         return getDefaultPhysicalFont();
  1117.                      case 2:
  1118.                         return getDefaultLogicalFont(var1);
  1119.                      default:
  1120.                         return null;
  1121.                   }
  1122.                }
  1123.             }
  1124.          }
  1125.       }
  1126.    }
  1127.  
  1128.    public static native Font2D getFont2D(Font var0);
  1129.  
  1130.    public static boolean usePlatformFontMetrics() {
  1131.       return usePlatformFontMetrics;
  1132.    }
  1133.  
  1134.    static native boolean getPlatformFontVar();
  1135.  
  1136.    public static short getLCIDFromLocale(Locale var0) {
  1137.       if (var0.equals(Locale.US)) {
  1138.          return 1033;
  1139.       } else {
  1140.          if (lcidMap == null) {
  1141.             createLCIDMap();
  1142.          }
  1143.  
  1144.          int var3;
  1145.          for(String var1 = var0.toString(); !"".equals(var1); var1 = var1.substring(0, var3)) {
  1146.             Short var2 = (Short)lcidMap.get(var1);
  1147.             if (var2 != null) {
  1148.                return var2;
  1149.             }
  1150.  
  1151.             var3 = var1.lastIndexOf(95);
  1152.             if (var3 < 1) {
  1153.                return 1033;
  1154.             }
  1155.          }
  1156.  
  1157.          return 1033;
  1158.       }
  1159.    }
  1160.  
  1161.    private static void addLCIDMapEntry(Map var0, String var1, short var2) {
  1162.       var0.put(var1, new Short(var2));
  1163.    }
  1164.  
  1165.    private static synchronized void createLCIDMap() {
  1166.       if (lcidMap == null) {
  1167.          HashMap var0 = new HashMap(200);
  1168.          addLCIDMapEntry(var0, "ar", (short)1025);
  1169.          addLCIDMapEntry(var0, "bg", (short)1026);
  1170.          addLCIDMapEntry(var0, "ca", (short)1027);
  1171.          addLCIDMapEntry(var0, "zh", (short)1028);
  1172.          addLCIDMapEntry(var0, "cs", (short)1029);
  1173.          addLCIDMapEntry(var0, "da", (short)1030);
  1174.          addLCIDMapEntry(var0, "de", (short)1031);
  1175.          addLCIDMapEntry(var0, "el", (short)1032);
  1176.          addLCIDMapEntry(var0, "es", (short)1034);
  1177.          addLCIDMapEntry(var0, "fi", (short)1035);
  1178.          addLCIDMapEntry(var0, "fr", (short)1036);
  1179.          addLCIDMapEntry(var0, "iw", (short)1037);
  1180.          addLCIDMapEntry(var0, "hu", (short)1038);
  1181.          addLCIDMapEntry(var0, "is", (short)1039);
  1182.          addLCIDMapEntry(var0, "it", (short)1040);
  1183.          addLCIDMapEntry(var0, "ja", (short)1041);
  1184.          addLCIDMapEntry(var0, "ko", (short)1042);
  1185.          addLCIDMapEntry(var0, "nl", (short)1043);
  1186.          addLCIDMapEntry(var0, "no", (short)1044);
  1187.          addLCIDMapEntry(var0, "pl", (short)1045);
  1188.          addLCIDMapEntry(var0, "pt", (short)1046);
  1189.          addLCIDMapEntry(var0, "rm", (short)1047);
  1190.          addLCIDMapEntry(var0, "ro", (short)1048);
  1191.          addLCIDMapEntry(var0, "ru", (short)1049);
  1192.          addLCIDMapEntry(var0, "hr", (short)1050);
  1193.          addLCIDMapEntry(var0, "sk", (short)1051);
  1194.          addLCIDMapEntry(var0, "sq", (short)1052);
  1195.          addLCIDMapEntry(var0, "sv", (short)1053);
  1196.          addLCIDMapEntry(var0, "th", (short)1054);
  1197.          addLCIDMapEntry(var0, "tr", (short)1055);
  1198.          addLCIDMapEntry(var0, "ur", (short)1056);
  1199.          addLCIDMapEntry(var0, "in", (short)1057);
  1200.          addLCIDMapEntry(var0, "uk", (short)1058);
  1201.          addLCIDMapEntry(var0, "be", (short)1059);
  1202.          addLCIDMapEntry(var0, "sl", (short)1060);
  1203.          addLCIDMapEntry(var0, "et", (short)1061);
  1204.          addLCIDMapEntry(var0, "lv", (short)1062);
  1205.          addLCIDMapEntry(var0, "lt", (short)1063);
  1206.          addLCIDMapEntry(var0, "fa", (short)1065);
  1207.          addLCIDMapEntry(var0, "vi", (short)1066);
  1208.          addLCIDMapEntry(var0, "hy", (short)1067);
  1209.          addLCIDMapEntry(var0, "eu", (short)1069);
  1210.          addLCIDMapEntry(var0, "mk", (short)1071);
  1211.          addLCIDMapEntry(var0, "tn", (short)1074);
  1212.          addLCIDMapEntry(var0, "xh", (short)1076);
  1213.          addLCIDMapEntry(var0, "zu", (short)1077);
  1214.          addLCIDMapEntry(var0, "af", (short)1078);
  1215.          addLCIDMapEntry(var0, "ka", (short)1079);
  1216.          addLCIDMapEntry(var0, "fo", (short)1080);
  1217.          addLCIDMapEntry(var0, "hi", (short)1081);
  1218.          addLCIDMapEntry(var0, "mt", (short)1082);
  1219.          addLCIDMapEntry(var0, "se", (short)1083);
  1220.          addLCIDMapEntry(var0, "gd", (short)1084);
  1221.          addLCIDMapEntry(var0, "ms", (short)1086);
  1222.          addLCIDMapEntry(var0, "kk", (short)1087);
  1223.          addLCIDMapEntry(var0, "ky", (short)1088);
  1224.          addLCIDMapEntry(var0, "sw", (short)1089);
  1225.          addLCIDMapEntry(var0, "tt", (short)1092);
  1226.          addLCIDMapEntry(var0, "bn", (short)1093);
  1227.          addLCIDMapEntry(var0, "pa", (short)1094);
  1228.          addLCIDMapEntry(var0, "gu", (short)1095);
  1229.          addLCIDMapEntry(var0, "ta", (short)1097);
  1230.          addLCIDMapEntry(var0, "te", (short)1098);
  1231.          addLCIDMapEntry(var0, "kn", (short)1099);
  1232.          addLCIDMapEntry(var0, "ml", (short)1100);
  1233.          addLCIDMapEntry(var0, "mr", (short)1102);
  1234.          addLCIDMapEntry(var0, "sa", (short)1103);
  1235.          addLCIDMapEntry(var0, "mn", (short)1104);
  1236.          addLCIDMapEntry(var0, "cy", (short)1106);
  1237.          addLCIDMapEntry(var0, "gl", (short)1110);
  1238.          addLCIDMapEntry(var0, "dv", (short)1125);
  1239.          addLCIDMapEntry(var0, "qu", (short)1131);
  1240.          addLCIDMapEntry(var0, "mi", (short)1153);
  1241.          addLCIDMapEntry(var0, "ar_IQ", (short)2049);
  1242.          addLCIDMapEntry(var0, "zh_CN", (short)2052);
  1243.          addLCIDMapEntry(var0, "de_CH", (short)2055);
  1244.          addLCIDMapEntry(var0, "en_GB", (short)2057);
  1245.          addLCIDMapEntry(var0, "es_MX", (short)2058);
  1246.          addLCIDMapEntry(var0, "fr_BE", (short)2060);
  1247.          addLCIDMapEntry(var0, "it_CH", (short)2064);
  1248.          addLCIDMapEntry(var0, "nl_BE", (short)2067);
  1249.          addLCIDMapEntry(var0, "no_NO_NY", (short)2068);
  1250.          addLCIDMapEntry(var0, "pt_PT", (short)2070);
  1251.          addLCIDMapEntry(var0, "ro_MD", (short)2072);
  1252.          addLCIDMapEntry(var0, "ru_MD", (short)2073);
  1253.          addLCIDMapEntry(var0, "sr_CS", (short)2074);
  1254.          addLCIDMapEntry(var0, "sv_FI", (short)2077);
  1255.          addLCIDMapEntry(var0, "az_AZ", (short)2092);
  1256.          addLCIDMapEntry(var0, "se_SE", (short)2107);
  1257.          addLCIDMapEntry(var0, "ga_IE", (short)2108);
  1258.          addLCIDMapEntry(var0, "ms_BN", (short)2110);
  1259.          addLCIDMapEntry(var0, "uz_UZ", (short)2115);
  1260.          addLCIDMapEntry(var0, "qu_EC", (short)2155);
  1261.          addLCIDMapEntry(var0, "ar_EG", (short)3073);
  1262.          addLCIDMapEntry(var0, "zh_HK", (short)3076);
  1263.          addLCIDMapEntry(var0, "de_AT", (short)3079);
  1264.          addLCIDMapEntry(var0, "en_AU", (short)3081);
  1265.          addLCIDMapEntry(var0, "fr_CA", (short)3084);
  1266.          addLCIDMapEntry(var0, "sr_CS", (short)3098);
  1267.          addLCIDMapEntry(var0, "se_FI", (short)3131);
  1268.          addLCIDMapEntry(var0, "qu_PE", (short)3179);
  1269.          addLCIDMapEntry(var0, "ar_LY", (short)4097);
  1270.          addLCIDMapEntry(var0, "zh_SG", (short)4100);
  1271.          addLCIDMapEntry(var0, "de_LU", (short)4103);
  1272.          addLCIDMapEntry(var0, "en_CA", (short)4105);
  1273.          addLCIDMapEntry(var0, "es_GT", (short)4106);
  1274.          addLCIDMapEntry(var0, "fr_CH", (short)4108);
  1275.          addLCIDMapEntry(var0, "hr_BA", (short)4122);
  1276.          addLCIDMapEntry(var0, "ar_DZ", (short)5121);
  1277.          addLCIDMapEntry(var0, "zh_MO", (short)5124);
  1278.          addLCIDMapEntry(var0, "de_LI", (short)5127);
  1279.          addLCIDMapEntry(var0, "en_NZ", (short)5129);
  1280.          addLCIDMapEntry(var0, "es_CR", (short)5130);
  1281.          addLCIDMapEntry(var0, "fr_LU", (short)5132);
  1282.          addLCIDMapEntry(var0, "bs_BA", (short)5146);
  1283.          addLCIDMapEntry(var0, "ar_MA", (short)6145);
  1284.          addLCIDMapEntry(var0, "en_IE", (short)6153);
  1285.          addLCIDMapEntry(var0, "es_PA", (short)6154);
  1286.          addLCIDMapEntry(var0, "fr_MC", (short)6156);
  1287.          addLCIDMapEntry(var0, "sr_BA", (short)6170);
  1288.          addLCIDMapEntry(var0, "ar_TN", (short)7169);
  1289.          addLCIDMapEntry(var0, "en_ZA", (short)7177);
  1290.          addLCIDMapEntry(var0, "es_DO", (short)7178);
  1291.          addLCIDMapEntry(var0, "sr_BA", (short)7194);
  1292.          addLCIDMapEntry(var0, "ar_OM", (short)8193);
  1293.          addLCIDMapEntry(var0, "en_JM", (short)8201);
  1294.          addLCIDMapEntry(var0, "es_VE", (short)8202);
  1295.          addLCIDMapEntry(var0, "ar_YE", (short)9217);
  1296.          addLCIDMapEntry(var0, "es_CO", (short)9226);
  1297.          addLCIDMapEntry(var0, "ar_SY", (short)10241);
  1298.          addLCIDMapEntry(var0, "en_BZ", (short)10249);
  1299.          addLCIDMapEntry(var0, "es_PE", (short)10250);
  1300.          addLCIDMapEntry(var0, "ar_JO", (short)11265);
  1301.          addLCIDMapEntry(var0, "en_TT", (short)11273);
  1302.          addLCIDMapEntry(var0, "es_AR", (short)11274);
  1303.          addLCIDMapEntry(var0, "ar_LB", (short)12289);
  1304.          addLCIDMapEntry(var0, "en_ZW", (short)12297);
  1305.          addLCIDMapEntry(var0, "es_EC", (short)12298);
  1306.          addLCIDMapEntry(var0, "ar_KW", (short)13313);
  1307.          addLCIDMapEntry(var0, "en_PH", (short)13321);
  1308.          addLCIDMapEntry(var0, "es_CL", (short)13322);
  1309.          addLCIDMapEntry(var0, "ar_AE", (short)14337);
  1310.          addLCIDMapEntry(var0, "es_UY", (short)14346);
  1311.          addLCIDMapEntry(var0, "ar_BH", (short)15361);
  1312.          addLCIDMapEntry(var0, "es_PY", (short)15370);
  1313.          addLCIDMapEntry(var0, "ar_QA", (short)16385);
  1314.          addLCIDMapEntry(var0, "es_BO", (short)16394);
  1315.          addLCIDMapEntry(var0, "es_SV", (short)17418);
  1316.          addLCIDMapEntry(var0, "es_HN", (short)18442);
  1317.          addLCIDMapEntry(var0, "es_NI", (short)19466);
  1318.          addLCIDMapEntry(var0, "es_PR", (short)20490);
  1319.          lcidMap = var0;
  1320.       }
  1321.    }
  1322.  
  1323.    public static int getNumFonts() {
  1324.       return physicalFonts.size() + maxCompFont;
  1325.    }
  1326.  
  1327.    private static boolean fontSupportsEncoding(Font var0, String var1) {
  1328.       return getFont2D(var0).supportsEncoding(var1);
  1329.    }
  1330.  
  1331.    public static synchronized native String getFontPath(boolean var0);
  1332.  
  1333.    public static synchronized native void setNativeFontPath(String var0);
  1334.  
  1335.    public static Font2D createFont2D(File var0, int var1, boolean var2) throws FontFormatException {
  1336.       String var3 = var0.getPath();
  1337.       Object var4 = null;
  1338.  
  1339.       try {
  1340.          switch (var1) {
  1341.             case 0:
  1342.                var4 = new TrueTypeFont(var3, (Object)null, 0, true);
  1343.                break;
  1344.             case 1:
  1345.                var4 = new Type1Font(var3, (Object)null);
  1346.                break;
  1347.             default:
  1348.                throw new FontFormatException("Unrecognised Font Format");
  1349.          }
  1350.       } catch (FontFormatException var10) {
  1351.          if (var2) {
  1352.             AccessController.doPrivileged(new 3(var0));
  1353.          }
  1354.  
  1355.          throw var10;
  1356.       }
  1357.  
  1358.       if (var2) {
  1359.          ((FileFont)var4).setFileToRemove(var0);
  1360.          synchronized(FontManager.class) {
  1361.             if (tmpFontFiles == null) {
  1362.                tmpFontFiles = new Vector();
  1363.             }
  1364.  
  1365.             tmpFontFiles.add(var0);
  1366.             if (fileCloser == null) {
  1367.                4 var7 = new 4();
  1368.                AccessController.doPrivileged(new 5(var7));
  1369.             }
  1370.          }
  1371.       }
  1372.  
  1373.       return (Font2D)var4;
  1374.    }
  1375.  
  1376.    public static synchronized String getFullNameByFileName(String var0) {
  1377.       PhysicalFont[] var1 = getPhysicalFonts();
  1378.  
  1379.       for(int var2 = 0; var2 < var1.length; ++var2) {
  1380.          if (var1[var2].platName.equals(var0)) {
  1381.             return var1[var2].getFontName((Locale)null);
  1382.          }
  1383.       }
  1384.  
  1385.       return null;
  1386.    }
  1387.  
  1388.    public static synchronized void deRegisterBadFont(Font2D var0) {
  1389.       if (var0 instanceof PhysicalFont) {
  1390.          if (logging) {
  1391.             logger.severe("Deregister bad font: " + var0);
  1392.          }
  1393.  
  1394.          replaceFont((PhysicalFont)var0, getDefaultPhysicalFont());
  1395.       }
  1396.    }
  1397.  
  1398.    public static synchronized void replaceFont(PhysicalFont var0, PhysicalFont var1) {
  1399.       if (var0.handle.font2D == var0) {
  1400.          var0.handle.font2D = var1;
  1401.          physicalFonts.remove(var0.fullName);
  1402.          fullNameToFont.remove(var0.fullName.toLowerCase(Locale.ENGLISH));
  1403.          FontFamily.remove(var0);
  1404.          if (localeFullNamesToFont != null) {
  1405.             Map.Entry[] var2 = (Map.Entry[])localeFullNamesToFont.entrySet().toArray(new Map.Entry[0]);
  1406.  
  1407.             for(int var3 = 0; var3 < var2.length; ++var3) {
  1408.                if (var2[var3].getValue() == var0) {
  1409.                   try {
  1410.                      var2[var3].setValue(var1);
  1411.                   } catch (Exception var5) {
  1412.                      localeFullNamesToFont.remove(var2[var3].getKey());
  1413.                   }
  1414.                }
  1415.             }
  1416.          }
  1417.  
  1418.          for(int var6 = 0; var6 < maxCompFont; ++var6) {
  1419.             if (var1.getRank() > 2) {
  1420.                compFonts[var6].replaceComponentFont(var0, var1);
  1421.             }
  1422.          }
  1423.  
  1424.       }
  1425.    }
  1426.  
  1427.    private static synchronized void loadLocaleNames() {
  1428.       if (localeFullNamesToFont == null) {
  1429.          localeFullNamesToFont = new HashMap();
  1430.          Font2D[] var0 = getRegisteredFonts();
  1431.  
  1432.          for(int var1 = 0; var1 < var0.length; ++var1) {
  1433.             if (var0[var1] instanceof TrueTypeFont) {
  1434.                TrueTypeFont var2 = (TrueTypeFont)var0[var1];
  1435.                String[] var3 = var2.getAllFullNames();
  1436.  
  1437.                for(int var4 = 0; var4 < var3.length; ++var4) {
  1438.                   localeFullNamesToFont.put(var3[var4], var2);
  1439.                }
  1440.  
  1441.                FontFamily var5 = FontFamily.getFamily(var2.familyName);
  1442.                if (var5 != null) {
  1443.                   FontFamily.addLocaleNames(var5, var2.getAllFamilyNames());
  1444.                }
  1445.             }
  1446.          }
  1447.  
  1448.       }
  1449.    }
  1450.  
  1451.    private static Font2D findFont2DAllLocales(String var0, int var1) {
  1452.       if (logging) {
  1453.          logger.info("Searching localised font names for:" + var0);
  1454.       }
  1455.  
  1456.       if (localeFullNamesToFont == null) {
  1457.          loadLocaleNames();
  1458.       }
  1459.  
  1460.       String var2 = var0.toLowerCase();
  1461.       Object var3 = null;
  1462.       FontFamily var4 = FontFamily.getLocaleFamily(var2);
  1463.       if (var4 != null) {
  1464.          Font2D var8 = var4.getFont(var1);
  1465.          if (var8 == null) {
  1466.             var8 = var4.getClosestStyle(var1);
  1467.          }
  1468.  
  1469.          if (var8 != null) {
  1470.             return var8;
  1471.          }
  1472.       }
  1473.  
  1474.       Font2D var9;
  1475.       synchronized(FontManager.class) {
  1476.          var9 = (Font2D)localeFullNamesToFont.get(var0);
  1477.       }
  1478.  
  1479.       if (var9 != null) {
  1480.          if (var9.style == var1 || var1 == 0) {
  1481.             return var9;
  1482.          }
  1483.  
  1484.          var4 = FontFamily.getFamily(var9.getFamilyName((Locale)null));
  1485.          if (var4 != null) {
  1486.             Font2D var11 = var4.getFont(var1);
  1487.             if (var11 != null) {
  1488.                return var11;
  1489.             }
  1490.  
  1491.             var11 = var4.getClosestStyle(var1);
  1492.             if (var11 != null) {
  1493.                if (!var11.canDoStyle(var1)) {
  1494.                   var11 = null;
  1495.                }
  1496.  
  1497.                return var11;
  1498.             }
  1499.          }
  1500.       }
  1501.  
  1502.       return var9;
  1503.    }
  1504.  
  1505.    static boolean maybeUsingAlternateCompositeFonts() {
  1506.       return usingAlternateComposites || usingPerAppContextComposites;
  1507.    }
  1508.  
  1509.    public static boolean usingAlternateCompositeFonts() {
  1510.       return usingAlternateComposites || usingPerAppContextComposites && AppContext.getAppContext().get(CompositeFont.class) != null;
  1511.    }
  1512.  
  1513.    private static boolean maybeMultiAppContext() {
  1514.       Boolean var0 = (Boolean)AccessController.doPrivileged(new 6());
  1515.       return var0;
  1516.    }
  1517.  
  1518.    public static synchronized void useAlternateFontforJALocales() {
  1519.       if (isWindows) {
  1520.          initSGEnv();
  1521.          if (!maybeMultiAppContext()) {
  1522.             gAltJAFont = true;
  1523.          } else {
  1524.             AppContext var0 = AppContext.getAppContext();
  1525.             var0.put(altJAFontKey, altJAFontKey);
  1526.          }
  1527.  
  1528.       }
  1529.    }
  1530.  
  1531.    public static boolean usingAlternateFontforJALocales() {
  1532.       if (!maybeMultiAppContext()) {
  1533.          return gAltJAFont;
  1534.       } else {
  1535.          AppContext var0 = AppContext.getAppContext();
  1536.          return var0.get(altJAFontKey) == altJAFontKey;
  1537.       }
  1538.    }
  1539.  
  1540.    public static synchronized void preferLocaleFonts() {
  1541.       initSGEnv();
  1542.       if (FontConfiguration.willReorderForStartupLocale()) {
  1543.          if (!maybeMultiAppContext()) {
  1544.             if (gLocalePref) {
  1545.                return;
  1546.             }
  1547.  
  1548.             gLocalePref = true;
  1549.             sgEnv.createCompositeFonts(fontNameCache, gLocalePref, gPropPref);
  1550.             usingAlternateComposites = true;
  1551.          } else {
  1552.             AppContext var0 = AppContext.getAppContext();
  1553.             if (var0.get(localeFontKey) == localeFontKey) {
  1554.                return;
  1555.             }
  1556.  
  1557.             var0.put(localeFontKey, localeFontKey);
  1558.             boolean var1 = var0.get(proportionalFontKey) == proportionalFontKey;
  1559.             Hashtable var2 = new Hashtable();
  1560.             var0.put(CompositeFont.class, var2);
  1561.             usingPerAppContextComposites = true;
  1562.             sgEnv.createCompositeFonts(var2, true, var1);
  1563.          }
  1564.  
  1565.       }
  1566.    }
  1567.  
  1568.    public static synchronized void preferProportionalFonts() {
  1569.       if (FontConfiguration.hasMonoToPropMap()) {
  1570.          initSGEnv();
  1571.          if (!maybeMultiAppContext()) {
  1572.             if (gPropPref) {
  1573.                return;
  1574.             }
  1575.  
  1576.             gPropPref = true;
  1577.             sgEnv.createCompositeFonts(fontNameCache, gLocalePref, gPropPref);
  1578.             usingAlternateComposites = true;
  1579.          } else {
  1580.             AppContext var0 = AppContext.getAppContext();
  1581.             if (var0.get(proportionalFontKey) == proportionalFontKey) {
  1582.                return;
  1583.             }
  1584.  
  1585.             var0.put(proportionalFontKey, proportionalFontKey);
  1586.             boolean var1 = var0.get(localeFontKey) == localeFontKey;
  1587.             Hashtable var2 = new Hashtable();
  1588.             var0.put(CompositeFont.class, var2);
  1589.             usingPerAppContextComposites = true;
  1590.             sgEnv.createCompositeFonts(var2, var1, true);
  1591.          }
  1592.  
  1593.       }
  1594.    }
  1595.  
  1596.    private static HashSet getInstalledNames() {
  1597.       if (installedNames == null) {
  1598.          SunGraphicsEnvironment var10000 = sgEnv;
  1599.          Locale var0 = SunGraphicsEnvironment.getSystemStartupLocale();
  1600.          String[] var1 = sgEnv.getInstalledFontFamilyNames(var0);
  1601.          Font[] var2 = sgEnv.getAllInstalledFonts();
  1602.          HashSet var3 = new HashSet();
  1603.  
  1604.          for(int var4 = 0; var4 < var1.length; ++var4) {
  1605.             var3.add(var1[var4].toLowerCase(var0));
  1606.          }
  1607.  
  1608.          for(int var5 = 0; var5 < var2.length; ++var5) {
  1609.             var3.add(var2[var5].getFontName(var0).toLowerCase(var0));
  1610.          }
  1611.  
  1612.          installedNames = var3;
  1613.       }
  1614.  
  1615.       return installedNames;
  1616.    }
  1617.  
  1618.    public static boolean registerFont(Font var0) {
  1619.       synchronized(regFamilyKey) {
  1620.          if (createdByFamilyName == null) {
  1621.             createdByFamilyName = new Hashtable();
  1622.             createdByFullName = new Hashtable();
  1623.          }
  1624.       }
  1625.  
  1626.       if (!isCreatedFont(var0)) {
  1627.          return false;
  1628.       } else {
  1629.          if (sgEnv == null) {
  1630.             initSGEnv();
  1631.          }
  1632.  
  1633.          HashSet var1 = getInstalledNames();
  1634.          SunGraphicsEnvironment var10000 = sgEnv;
  1635.          Locale var2 = SunGraphicsEnvironment.getSystemStartupLocale();
  1636.          String var3 = var0.getFamily(var2).toLowerCase();
  1637.          String var4 = var0.getFontName(var2).toLowerCase();
  1638.          if (!var1.contains(var3) && !var1.contains(var4)) {
  1639.             Hashtable var5;
  1640.             Hashtable var6;
  1641.             if (!maybeMultiAppContext()) {
  1642.                var5 = createdByFamilyName;
  1643.                var6 = createdByFullName;
  1644.                fontsAreRegistered = true;
  1645.             } else {
  1646.                AppContext var7 = AppContext.getAppContext();
  1647.                var5 = (Hashtable)var7.get(regFamilyKey);
  1648.                var6 = (Hashtable)var7.get(regFullNameKey);
  1649.                if (var5 == null) {
  1650.                   var5 = new Hashtable();
  1651.                   var6 = new Hashtable();
  1652.                   var7.put(regFamilyKey, var5);
  1653.                   var7.put(regFullNameKey, var6);
  1654.                }
  1655.  
  1656.                fontsAreRegisteredPerAppContext = true;
  1657.             }
  1658.  
  1659.             Font2D var11 = getFont2D(var0);
  1660.             int var8 = var11.getStyle();
  1661.             FontFamily var9 = (FontFamily)var5.get(var3);
  1662.             if (var9 == null) {
  1663.                var9 = new FontFamily(var0.getFamily(var2));
  1664.                var5.put(var3, var9);
  1665.             }
  1666.  
  1667.             if (fontsAreRegistered) {
  1668.                removeFromCache(var9.getFont(0));
  1669.                removeFromCache(var9.getFont(1));
  1670.                removeFromCache(var9.getFont(2));
  1671.                removeFromCache(var9.getFont(3));
  1672.                removeFromCache((Font2D)var6.get(var4));
  1673.             }
  1674.  
  1675.             var9.setFont(var11, var8);
  1676.             var6.put(var4, var11);
  1677.             return true;
  1678.          } else {
  1679.             return false;
  1680.          }
  1681.       }
  1682.    }
  1683.  
  1684.    private static void removeFromCache(Font2D var0) {
  1685.       if (var0 != null) {
  1686.          String[] var1 = (String[])fontNameCache.keySet().toArray(STR_ARRAY);
  1687.  
  1688.          for(int var2 = 0; var2 < var1.length; ++var2) {
  1689.             if (fontNameCache.get(var1[var2]) == var0) {
  1690.                fontNameCache.remove(var1[var2]);
  1691.             }
  1692.          }
  1693.  
  1694.       }
  1695.    }
  1696.  
  1697.    public static TreeMap<String, String> getCreatedFontFamilyNames() {
  1698.       Hashtable var0;
  1699.       if (fontsAreRegistered) {
  1700.          var0 = createdByFamilyName;
  1701.       } else {
  1702.          if (!fontsAreRegisteredPerAppContext) {
  1703.             return null;
  1704.          }
  1705.  
  1706.          AppContext var1 = AppContext.getAppContext();
  1707.          var0 = (Hashtable)var1.get(regFamilyKey);
  1708.       }
  1709.  
  1710.       SunGraphicsEnvironment var10000 = sgEnv;
  1711.       Locale var10 = SunGraphicsEnvironment.getSystemStartupLocale();
  1712.       synchronized(var0) {
  1713.          TreeMap var3 = new TreeMap();
  1714.  
  1715.          for(FontFamily var5 : var0.values()) {
  1716.             Font2D var6 = var5.getFont(0);
  1717.             if (var6 == null) {
  1718.                var6 = var5.getClosestStyle(0);
  1719.             }
  1720.  
  1721.             String var7 = var6.getFamilyName(var10);
  1722.             var3.put(var7.toLowerCase(var10), var7);
  1723.          }
  1724.  
  1725.          return var3;
  1726.       }
  1727.    }
  1728.  
  1729.    public static Font[] getCreatedFonts() {
  1730.       Hashtable var0;
  1731.       if (fontsAreRegistered) {
  1732.          var0 = createdByFullName;
  1733.       } else {
  1734.          if (!fontsAreRegisteredPerAppContext) {
  1735.             return null;
  1736.          }
  1737.  
  1738.          AppContext var1 = AppContext.getAppContext();
  1739.          var0 = (Hashtable)var1.get(regFullNameKey);
  1740.       }
  1741.  
  1742.       SunGraphicsEnvironment var10000 = sgEnv;
  1743.       Locale var9 = SunGraphicsEnvironment.getSystemStartupLocale();
  1744.       synchronized(var0) {
  1745.          Font[] var3 = new Font[var0.size()];
  1746.          int var4 = 0;
  1747.  
  1748.          for(Font2D var6 : var0.values()) {
  1749.             var3[var4++] = new Font(var6.getFontName(var9), 0, 1);
  1750.          }
  1751.  
  1752.          return var3;
  1753.       }
  1754.    }
  1755.  
  1756.    public static String mapFcName(String var0) {
  1757.       for(int var1 = 0; var1 < nameMap.length; ++var1) {
  1758.          if (var0.equals(nameMap[var1][0])) {
  1759.             return nameMap[var1][1];
  1760.          }
  1761.       }
  1762.  
  1763.       return null;
  1764.    }
  1765.  
  1766.    private static String getFCLocaleStr() {
  1767.       Locale var0 = SunToolkit.getStartupLocale();
  1768.       String var1 = var0.getLanguage();
  1769.       String var2 = var0.getCountry();
  1770.       if (!var2.equals("")) {
  1771.          var1 = var1 + "-" + var2;
  1772.       }
  1773.  
  1774.       return var1;
  1775.    }
  1776.  
  1777.    private static native int getFontConfigAASettings(String var0, String var1);
  1778.  
  1779.    public static Object getFontConfigAAHint(String var0) {
  1780.       if (isWindows) {
  1781.          return null;
  1782.       } else {
  1783.          int var1 = getFontConfigAASettings(getFCLocaleStr(), var0);
  1784.          return var1 < 0 ? null : Value.get(2, var1);
  1785.       }
  1786.    }
  1787.  
  1788.    public static Object getFontConfigAAHint() {
  1789.       return getFontConfigAAHint("sans");
  1790.    }
  1791.  
  1792.    private static native void getFontConfig(String var0, FontConfigInfo[] var1);
  1793.  
  1794.    private static void initFontConfigFonts() {
  1795.       if (!isWindows) {
  1796.          FontConfigInfo[] var0 = new FontConfigInfo[fontConfigNames.length];
  1797.  
  1798.          for(int var1 = 0; var1 < var0.length; ++var1) {
  1799.             var0[var1] = new FontConfigInfo((1)null);
  1800.             var0[var1].fcName = fontConfigNames[var1];
  1801.             int var2 = var0[var1].fcName.indexOf(58);
  1802.             var0[var1].fcFamily = var0[var1].fcName.substring(0, var2);
  1803.             var0[var1].jdkName = mapFcName(var0[var1].fcFamily);
  1804.             var0[var1].style = var1 % 4;
  1805.          }
  1806.  
  1807.          getFontConfig(getFCLocaleStr(), var0);
  1808.          fontConfigFonts = var0;
  1809.       }
  1810.    }
  1811.  
  1812.    private static PhysicalFont registerFromFcInfo(FontConfigInfo var0) {
  1813.       int var1 = var0.fontFile.length() - 4;
  1814.       if (var1 <= 0) {
  1815.          return null;
  1816.       } else {
  1817.          String var2 = var0.fontFile.substring(var1).toLowerCase();
  1818.          boolean var3 = var2.equals(".ttc");
  1819.          PhysicalFont var4 = (PhysicalFont)registeredFontFiles.get(var0.fontFile);
  1820.          if (var4 != null) {
  1821.             if (var3) {
  1822.                Font2D var9 = findFont2D(var0.familyName, var0.style, 0);
  1823.                return var9 instanceof PhysicalFont ? (PhysicalFont)var9 : null;
  1824.             } else {
  1825.                return var4;
  1826.             }
  1827.          } else {
  1828.             var4 = findJREDeferredFont(var0.familyName, var0.style);
  1829.             if (var4 == null && deferredFontFiles.get(var0.fontFile) != null) {
  1830.                var4 = initialiseDeferredFont(var0.fontFile);
  1831.                if (var4 != null) {
  1832.                   if (var3) {
  1833.                      Font2D var8 = findFont2D(var0.familyName, var0.style, 0);
  1834.                      if (var8 instanceof PhysicalFont) {
  1835.                         return (PhysicalFont)var8;
  1836.                      }
  1837.  
  1838.                      return null;
  1839.                   }
  1840.  
  1841.                   return var4;
  1842.                }
  1843.             }
  1844.  
  1845.             if (var4 == null) {
  1846.                byte var5 = -1;
  1847.                byte var6 = 6;
  1848.                if (!var2.equals(".ttf") && !var3) {
  1849.                   if (var2.equals(".pfa") || var2.equals(".pfb")) {
  1850.                      var5 = 1;
  1851.                      var6 = 4;
  1852.                   }
  1853.                } else {
  1854.                   var5 = 0;
  1855.                   var6 = 3;
  1856.                }
  1857.  
  1858.                var4 = registerFontFile(var0.fontFile, (String[])null, var5, true, var6);
  1859.             }
  1860.  
  1861.             return var4;
  1862.          }
  1863.       }
  1864.    }
  1865.  
  1866.    private static CompositeFont getFontConfigFont(String var0, int var1) {
  1867.       PhysicalFont var2 = null;
  1868.       if (fontConfigFonts == null) {
  1869.          long var3 = 0L;
  1870.          if (logging) {
  1871.             var3 = System.currentTimeMillis();
  1872.          }
  1873.  
  1874.          initFontConfigFonts();
  1875.          if (logging) {
  1876.             long var5 = System.currentTimeMillis();
  1877.             logger.info("Time spent accessing fontconfig=" + (var5 - var3) + "ms.");
  1878.  
  1879.             for(int var7 = 0; var7 < fontConfigFonts.length; ++var7) {
  1880.                FontConfigInfo var8 = fontConfigFonts[var7];
  1881.                logger.info("FC font " + var8.fcName + " maps to family " + var8.familyName + " in file " + var8.fontFile);
  1882.             }
  1883.          }
  1884.       }
  1885.  
  1886.       var0 = var0.toLowerCase();
  1887.       FontConfigInfo var10 = null;
  1888.  
  1889.       for(int var4 = 0; var4 < fontConfigFonts.length; ++var4) {
  1890.          if (var0.equals(fontConfigFonts[var4].fcFamily) && var1 == fontConfigFonts[var4].style) {
  1891.             var10 = fontConfigFonts[var4];
  1892.             break;
  1893.          }
  1894.       }
  1895.  
  1896.       if (var10 == null) {
  1897.          var10 = fontConfigFonts[0];
  1898.       }
  1899.  
  1900.       if (logging) {
  1901.          logger.info("FC name=" + var0 + " style=" + var1 + " uses " + var10.familyName + " in file: " + var10.fontFile);
  1902.       }
  1903.  
  1904.       if (var10.compFont != null) {
  1905.          return var10.compFont;
  1906.       } else {
  1907.          CompositeFont var11 = (CompositeFont)findFont2D(var10.jdkName, var1, 2);
  1908.          if (var10.familyName != null && var10.fontFile != null) {
  1909.             FontFamily var12 = FontFamily.getFamily(var10.familyName);
  1910.             if (var12 != null) {
  1911.                Font2D var6 = var12.getFontWithExactStyleMatch(var10.style);
  1912.                if (var6 instanceof PhysicalFont) {
  1913.                   var2 = (PhysicalFont)var6;
  1914.                }
  1915.             }
  1916.  
  1917.             if (var2 == null || !var10.fontFile.equals(var2.platName)) {
  1918.                var2 = registerFromFcInfo(var10);
  1919.                if (var2 == null) {
  1920.                   return var10.compFont = var11;
  1921.                }
  1922.  
  1923.                var12 = FontFamily.getFamily(var2.getFamilyName((Locale)null));
  1924.             }
  1925.  
  1926.             for(int var13 = 0; var13 < fontConfigFonts.length; ++var13) {
  1927.                FontConfigInfo var14 = fontConfigFonts[var13];
  1928.                if (var14 != var10 && var2.getFamilyName((Locale)null).equals(var14.familyName) && !var14.fontFile.equals(var2.platName) && var12.getFontWithExactStyleMatch(var14.style) == null) {
  1929.                   registerFromFcInfo(fontConfigFonts[var13]);
  1930.                }
  1931.             }
  1932.  
  1933.             return var10.compFont = new CompositeFont(var2, var11);
  1934.          } else {
  1935.             return var10.compFont = var11;
  1936.          }
  1937.       }
  1938.    }
  1939.  
  1940.    public static FontUIResource getFontConfigFUIR(String var0, int var1, int var2) {
  1941.       String var3 = mapFcName(var0);
  1942.       if (var3 == null) {
  1943.          var3 = "sansserif";
  1944.       }
  1945.  
  1946.       if (isWindows) {
  1947.          return new FontUIResource(var3, var1, var2);
  1948.       } else {
  1949.          CompositeFont var4 = getFontConfigFont(var0, var1);
  1950.          if (var4 == null) {
  1951.             return new FontUIResource(var3, var1, var2);
  1952.          } else {
  1953.             FontUIResource var5 = new FontUIResource(var4.getFamilyName((Locale)null), var1, var2);
  1954.             setFont2D(var5, var4.handle);
  1955.             setCreatedFont(var5);
  1956.             return var5;
  1957.          }
  1958.       }
  1959.    }
  1960.  
  1961.    // $FF: synthetic method
  1962.    static void access$000() {
  1963.       initIDs();
  1964.    }
  1965.  
  1966.    // $FF: synthetic method
  1967.    static boolean access$102(boolean var0) {
  1968.       usePlatformFontMetrics = var0;
  1969.       return var0;
  1970.    }
  1971.  
  1972.    // $FF: synthetic method
  1973.    static String[] access$200() {
  1974.       return pathDirs;
  1975.    }
  1976.  
  1977.    // $FF: synthetic method
  1978.    static String[] access$300() {
  1979.       return STR_ARRAY;
  1980.    }
  1981.  
  1982.    // $FF: synthetic method
  1983.    static FileFont[] access$400() {
  1984.       return fontFileCache;
  1985.    }
  1986.  
  1987.    // $FF: synthetic method
  1988.    static Thread access$502(Thread var0) {
  1989.       fileCloser = var0;
  1990.       return var0;
  1991.    }
  1992.  
  1993.    // $FF: synthetic method
  1994.    static Thread access$500() {
  1995.       return fileCloser;
  1996.    }
  1997.  
  1998.    static {
  1999.       if (SunGraphicsEnvironment.debugFonts) {
  2000.          logger = Logger.getLogger("sun.java2d", (String)null);
  2001.          logging = logger.getLevel() != Level.OFF;
  2002.       }
  2003.  
  2004.       jreFontMap = new HashMap();
  2005.       jreFontMap.put("lucida sans0", "LucidaSansRegular.ttf");
  2006.       jreFontMap.put("lucida sans1", "LucidaSansDemiBold.ttf");
  2007.       jreFontMap.put("lucida sans regular0", "LucidaSansRegular.ttf");
  2008.       jreFontMap.put("lucida sans regular1", "LucidaSansDemiBold.ttf");
  2009.       jreFontMap.put("lucida sans bold1", "LucidaSansDemiBold.ttf");
  2010.       jreFontMap.put("lucida sans demibold1", "LucidaSansDemiBold.ttf");
  2011.       jreFontMap.put("lucida sans typewriter0", "LucidaTypewriter.ttf");
  2012.       jreFontMap.put("lucida sans typewriter1", "LucidaTypewriterBold.ttf");
  2013.       jreFontMap.put("lucida sans typewriter regular0", "LucidaTypewriter.ttf");
  2014.       jreFontMap.put("lucida sans typewriter regular1", "LucidaTypewriterBold.ttf");
  2015.       jreFontMap.put("lucida sans typewriter bold1", "LucidaTypewriterBold.ttf");
  2016.       jreFontMap.put("lucida sans typewriter demibold1", "LucidaTypewriterBold.ttf");
  2017.       jreFontMap.put("lucida bright0", "LucidaBrightRegular.ttf");
  2018.       jreFontMap.put("lucida bright1", "LucidaBrightDemiBold.ttf");
  2019.       jreFontMap.put("lucida bright2", "LucidaBrightItalic.ttf");
  2020.       jreFontMap.put("lucida bright3", "LucidaBrightDemiItalic.ttf");
  2021.       jreFontMap.put("lucida bright regular0", "LucidaBrightRegular.ttf");
  2022.       jreFontMap.put("lucida bright regular1", "LucidaBrightDemiBold.ttf");
  2023.       jreFontMap.put("lucida bright regular2", "LucidaBrightItalic.ttf");
  2024.       jreFontMap.put("lucida bright regular3", "LucidaBrightDemiItalic.ttf");
  2025.       jreFontMap.put("lucida bright bold1", "LucidaBrightDemiBold.ttf");
  2026.       jreFontMap.put("lucida bright bold3", "LucidaBrightDemiItalic.ttf");
  2027.       jreFontMap.put("lucida bright demibold1", "LucidaBrightDemiBold.ttf");
  2028.       jreFontMap.put("lucida bright demibold3", "LucidaBrightDemiItalic.ttf");
  2029.       jreFontMap.put("lucida bright italic2", "LucidaBrightItalic.ttf");
  2030.       jreFontMap.put("lucida bright italic3", "LucidaBrightDemiItalic.ttf");
  2031.       jreFontMap.put("lucida bright bold italic3", "LucidaBrightDemiItalic.ttf");
  2032.       jreFontMap.put("lucida bright demibold italic3", "LucidaBrightDemiItalic.ttf");
  2033.       jreLucidaFontFiles = new HashSet();
  2034.       String[] var0 = (String[])jreFontMap.values().toArray(STR_ARRAY);
  2035.  
  2036.       for(int var1 = 0; var1 < var0.length; ++var1) {
  2037.          jreLucidaFontFiles.add(var0[var1]);
  2038.       }
  2039.  
  2040.       AccessController.doPrivileged(new 1());
  2041.       deferredFontFiles = new Hashtable();
  2042.       initialisedFonts = new Hashtable();
  2043.       fontToFileMap = null;
  2044.       fontToFamilyNameMap = null;
  2045.       familyToFontListMap = null;
  2046.       pathDirs = null;
  2047.       fontNameCache = new Hashtable(10, 0.75F);
  2048.       fileCloser = null;
  2049.       tmpFontFiles = null;
  2050.       altJAFontKey = new Object();
  2051.       localeFontKey = new Object();
  2052.       proportionalFontKey = new Object();
  2053.       usingPerAppContextComposites = false;
  2054.       usingAlternateComposites = false;
  2055.       gAltJAFont = false;
  2056.       gLocalePref = false;
  2057.       gPropPref = false;
  2058.       installedNames = null;
  2059.       regFamilyKey = new Object();
  2060.       regFullNameKey = new Object();
  2061.       fontsAreRegistered = false;
  2062.       fontsAreRegisteredPerAppContext = false;
  2063.       nameMap = new String[][]{{"sans", "sansserif"}, {"sans-serif", "sansserif"}, {"serif", "serif"}, {"monospace", "monospaced"}};
  2064.       fontConfigNames = new String[]{"sans:regular:roman", "sans:bold:roman", "sans:regular:italic", "sans:bold:italic", "serif:regular:roman", "serif:bold:roman", "serif:regular:italic", "serif:bold:italic", "monospace:regular:roman", "monospace:bold:roman", "monospace:regular:italic", "monospace:bold:italic"};
  2065.    }
  2066. }
  2067.